﻿using System;
using System.Runtime.InteropServices;

namespace Teigha.Core
{
	public class Globals
	{
		public static double kMmPerInch
		{
			get
			{
				double result = GlobalsPINVOKE.kMmPerInch_get();
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
		}

		public static bool OdPositive(double x, double tol)
		{
			bool result = GlobalsPINVOKE.OdPositive__SWIG_0(x, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdPositive(double x)
		{
			bool result = GlobalsPINVOKE.OdPositive__SWIG_1(x);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdNegative(double x, double tol)
		{
			bool result = GlobalsPINVOKE.OdNegative__SWIG_0(x, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdNegative(double x)
		{
			bool result = GlobalsPINVOKE.OdNegative__SWIG_1(x);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdZero(double x, double tol)
		{
			bool result = GlobalsPINVOKE.OdZero__SWIG_0(x, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdZero(double x)
		{
			bool result = GlobalsPINVOKE.OdZero__SWIG_1(x);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdNonZero(double x, double tol)
		{
			bool result = GlobalsPINVOKE.OdNonZero__SWIG_0(x, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdNonZero(double x)
		{
			bool result = GlobalsPINVOKE.OdNonZero__SWIG_1(x);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdEqual(double x, double y, double tol)
		{
			bool result = GlobalsPINVOKE.OdEqual__SWIG_0(x, y, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdEqual(double x, double y)
		{
			bool result = GlobalsPINVOKE.OdEqual__SWIG_1(x, y);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdLess(double x, double y, double tol)
		{
			bool result = GlobalsPINVOKE.OdLess__SWIG_0(x, y, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdLess(double x, double y)
		{
			bool result = GlobalsPINVOKE.OdLess__SWIG_1(x, y);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdLessOrEqual(double x, double y, double tol)
		{
			bool result = GlobalsPINVOKE.OdLessOrEqual__SWIG_0(x, y, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdLessOrEqual(double x, double y)
		{
			bool result = GlobalsPINVOKE.OdLessOrEqual__SWIG_1(x, y);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdGreater(double x, double y, double tol)
		{
			bool result = GlobalsPINVOKE.OdGreater__SWIG_0(x, y, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdGreater(double x, double y)
		{
			bool result = GlobalsPINVOKE.OdGreater__SWIG_1(x, y);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdGreaterOrEqual(double x, double y, double tol)
		{
			bool result = GlobalsPINVOKE.OdGreaterOrEqual__SWIG_0(x, y, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool OdGreaterOrEqual(double x, double y)
		{
			bool result = GlobalsPINVOKE.OdGreaterOrEqual__SWIG_1(x, y);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static double OdSign(double x)
		{
			double result = GlobalsPINVOKE.OdSign__SWIG_0(x);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static int OdSign(int x)
		{
			int result = GlobalsPINVOKE.OdSign__SWIG_1(x);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static int OdCmpDouble(double x, double y, double tol)
		{
			int result = GlobalsPINVOKE.OdCmpDouble__SWIG_0(x, y, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static int OdCmpDouble(double x, double y)
		{
			int result = GlobalsPINVOKE.OdCmpDouble__SWIG_1(x, y);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static double safeDivide(double a, double b)
		{
			double result = GlobalsPINVOKE.safeDivide(a, b);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxObject odrxCreateObject(string sClassName)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.odrxCreateObject(sClassName);
			OdRxObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void odrxRegisterDestructorCallback(OdRxObjectDelegate callbackFunc)
		{
			GlobalsPINVOKE.odrxRegisterDestructorCallback(callbackFunc);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void odrxUnregisterDestructorCallback()
		{
			GlobalsPINVOKE.odrxUnregisterDestructorCallback();
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static OdEdCommandStack odedRegCmds()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.odedRegCmds();
			OdEdCommandStack result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdCommandStack)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdCommandStack)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdCommandStack)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool odrxInitialize(OdRxSystemServices pSysSvcs)
		{
			bool result = GlobalsPINVOKE.odrxInitialize(OdRxSystemServices.getCPtr(pSysSvcs));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void odrxUninitialize()
		{
			GlobalsPINVOKE.odrxUninitialize();
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static OdRxDictionary odrxSysRegistry()
		{
			OdRxDictionary result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.odrxSysRegistry(), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxSystemServices odrxSystemServices()
		{
			OdRxSystemServices result = new OdRxSystemServices(GlobalsPINVOKE.odrxSystemServices(), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxDictionary odrxClassDictionary()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.odrxClassDictionary();
			OdRxDictionary result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxDictionary odrxServiceDictionary()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.odrxServiceDictionary();
			OdRxDictionary result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxDictionary odrxCreateRxDictionary()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.odrxCreateRxDictionary();
			OdRxDictionary result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxDictionary odrxCreateSyncRxDictionary()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.odrxCreateSyncRxDictionary();
			OdRxDictionary result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxDynamicLinker odrxDynamicLinker()
		{
			OdRxDynamicLinker result = (OdRxDynamicLinker)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.odrxDynamicLinker(), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void odgeHeapCleanup()
		{
			GlobalsPINVOKE.odgeHeapCleanup();
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static OdGePoint3d Mul(OdGeMatrix3d matrix, OdGePoint3d point)
		{
			OdGePoint3d result = new OdGePoint3d(GlobalsPINVOKE.Mul__SWIG_0(OdGeMatrix3d.getCPtr(matrix), OdGePoint3d.getCPtr(point)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGePoint3d Mul(double scale, OdGePoint3d point)
		{
			OdGePoint3d result = new OdGePoint3d(GlobalsPINVOKE.Mul__SWIG_1(scale, OdGePoint3d.getCPtr(point)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeVector3d Mul(OdGeMatrix3d matrix, OdGeVector3d vect)
		{
			OdGeVector3d result = new OdGeVector3d(GlobalsPINVOKE.Mul__SWIG_2(OdGeMatrix3d.getCPtr(matrix), OdGeVector3d.getCPtr(vect)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeVector3d Mul(double scale, OdGeVector3d vect)
		{
			OdGeVector3d result = new OdGeVector3d(GlobalsPINVOKE.Mul__SWIG_3(scale, OdGeVector3d.getCPtr(vect)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGePoint2d Mul(OdGeMatrix2d matrix, OdGePoint2d point)
		{
			OdGePoint2d result = new OdGePoint2d(GlobalsPINVOKE.Mul__SWIG_4(OdGeMatrix2d.getCPtr(matrix), OdGePoint2d.getCPtr(point)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeVector2d Mul(OdGeMatrix2d xfm, OdGeVector2d vect)
		{
			OdGeVector2d result = new OdGeVector2d(GlobalsPINVOKE.Mul__SWIG_5(OdGeMatrix2d.getCPtr(xfm), OdGeVector2d.getCPtr(vect)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeVector2d Mul(double scale, OdGeVector2d vector)
		{
			OdGeVector2d result = new OdGeVector2d(GlobalsPINVOKE.Mul__SWIG_6(scale, OdGeVector2d.getCPtr(vector)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geValidSolid(OdGePoint3dArray points, out bool isValid, OdGeTol tol)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geValidSolid__SWIG_0(OdGePoint3dArray.getCPtr(points), out isValid, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geValidSolid(OdGePoint3dArray points, out bool isValid)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geValidSolid__SWIG_1(OdGePoint3dArray.getCPtr(points), out isValid);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geSolidSignedVolume(OdGePoint3dArray points, out double volume, OdGePoint3d basePoint)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geSolidSignedVolume(OdGePoint3dArray.getCPtr(points), out volume, OdGePoint3d.getCPtr(basePoint));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculateNormal(OdGePoint3dArray points, OdGeVector3d pNormal, OdGeTol tol)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculateNormal__SWIG_0(OdGePoint3dArray.getCPtr(points), OdGeVector3d.getCPtr(pNormal), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculateNormal(OdGePoint3dArray points, OdGeVector3d pNormal)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculateNormal__SWIG_1(OdGePoint3dArray.getCPtr(points), OdGeVector3d.getCPtr(pNormal));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculateNormal(OdGePoint3d[] points, OdGeVector3d pNormal, OdGeTol tol)
		{
			IntPtr intPtr = Teigha.Core.Helpers.MarshalPoint3dArray(points);
			OdGe.ErrorCondition result;
			try
			{
				OdGe.ErrorCondition errorCondition = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculateNormal__SWIG_2(intPtr, OdGeVector3d.getCPtr(pNormal), OdGeTol.getCPtr(tol));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				result = errorCondition;
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculateNormal(OdGePoint3d[] points, OdGeVector3d pNormal)
		{
			IntPtr intPtr = Teigha.Core.Helpers.MarshalPoint3dArray(points);
			OdGe.ErrorCondition result;
			try
			{
				OdGe.ErrorCondition errorCondition = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculateNormal__SWIG_3(intPtr, OdGeVector3d.getCPtr(pNormal));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				result = errorCondition;
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculatePlane(OdGePoint3dArray points, OdGePlane plane, OdGeTol tol)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculatePlane__SWIG_0(OdGePoint3dArray.getCPtr(points), OdGePlane.getCPtr(plane), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculatePlane(OdGePoint3dArray points, OdGePlane plane)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculatePlane__SWIG_1(OdGePoint3dArray.getCPtr(points), OdGePlane.getCPtr(plane));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculatePlane(OdGePoint3d[] points, OdGePlane plane, OdGeTol tol)
		{
			IntPtr intPtr = Teigha.Core.Helpers.MarshalPoint3dArray(points);
			OdGe.ErrorCondition result;
			try
			{
				OdGe.ErrorCondition errorCondition = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculatePlane__SWIG_2(intPtr, OdGePlane.getCPtr(plane), OdGeTol.getCPtr(tol));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				result = errorCondition;
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculatePlane(OdGePoint3d[] points, OdGePlane plane)
		{
			IntPtr intPtr = Teigha.Core.Helpers.MarshalPoint3dArray(points);
			OdGe.ErrorCondition result;
			try
			{
				OdGe.ErrorCondition errorCondition = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculatePlane__SWIG_3(intPtr, OdGePlane.getCPtr(plane));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				result = errorCondition;
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculatePlane(OdGeCurve3d[] curves, uint numCurves, OdGePlane plane, OdGeTol tol)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculatePlane__SWIG_4(curves, numCurves, OdGePlane.getCPtr(plane), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGe.ErrorCondition geCalculatePlane(OdGeCurve3d[] curves, uint numCurves, OdGePlane plane)
		{
			OdGe.ErrorCondition result = (OdGe.ErrorCondition)GlobalsPINVOKE.geCalculatePlane__SWIG_5(curves, numCurves, OdGePlane.getCPtr(plane));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool geNurb3dTo2d(OdGeNurbCurve3d nurb3d, OdGePlane plane, OdGeNurbCurve2d nurb2d, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.geNurb3dTo2d__SWIG_0(OdGeNurbCurve3d.getCPtr(nurb3d), OdGePlane.getCPtr(plane), OdGeNurbCurve2d.getCPtr(nurb2d), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool geNurb3dTo2d(OdGeNurbCurve3d nurb3d, OdGePlane plane, OdGeNurbCurve2d nurb2d)
		{
			bool result = GlobalsPINVOKE.geNurb3dTo2d__SWIG_1(OdGeNurbCurve3d.getCPtr(nurb3d), OdGePlane.getCPtr(plane), OdGeNurbCurve2d.getCPtr(nurb2d));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool geSurfaceProp(OdGeSurface pS, SWIGTYPE_p_OdGe__NurbSurfaceProperties propU, SWIGTYPE_p_OdGe__NurbSurfaceProperties propV, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.geSurfaceProp(OdGeSurface.getCPtr(pS), SWIGTYPE_p_OdGe__NurbSurfaceProperties.getCPtr(propU), SWIGTYPE_p_OdGe__NurbSurfaceProperties.getCPtr(propV), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static string geToString(OdGe.EntityId val)
		{
			string result = GlobalsPINVOKE.geToString((int)val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void GE_ERROR(OdResult res)
		{
			GlobalsPINVOKE.GE_ERROR((int)res);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static double calibrateAngle(double val, double input)
		{
			double result = GlobalsPINVOKE.calibrateAngle(val, input);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static double angleFromParam(double param, double radiusRatio)
		{
			double result = GlobalsPINVOKE.angleFromParam(param, radiusRatio);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static double paramFromAngle(double angle, double radiusRatio)
		{
			double result = GlobalsPINVOKE.paramFromAngle(angle, radiusRatio);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdRxObject baseDatabaseBy(OdDbStub id)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.baseDatabaseBy(OdDbStub.getCPtr(id)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool properExtents(OdGeExtents3d ext)
		{
			bool result = GlobalsPINVOKE.properExtents(OdGeExtents3d.getCPtr(ext));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool odgiIsValidClipBoundary(OdGePoint2dArray points)
		{
			bool result = GlobalsPINVOKE.odgiIsValidClipBoundary(OdGePoint2dArray.getCPtr(points).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Add(OdGiColorRGB c1, OdGiColorRGB c2)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Add__SWIG_0(OdGiColorRGB.getCPtr(c1), OdGiColorRGB.getCPtr(c2)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Add(OdGiColorRGB c, double s)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Add__SWIG_1(OdGiColorRGB.getCPtr(c), s), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Add(double s, OdGiColorRGB c)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Add__SWIG_2(s, OdGiColorRGB.getCPtr(c)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Sub(OdGiColorRGB c1, OdGiColorRGB c2)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Sub__SWIG_0(OdGiColorRGB.getCPtr(c1), OdGiColorRGB.getCPtr(c2)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Sub(OdGiColorRGB c, double s)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Sub__SWIG_1(OdGiColorRGB.getCPtr(c), s), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Sub(double s, OdGiColorRGB c)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Sub__SWIG_2(s, OdGiColorRGB.getCPtr(c)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Mul(OdGiColorRGB c1, OdGiColorRGB c2)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Mul__SWIG_7(OdGiColorRGB.getCPtr(c1), OdGiColorRGB.getCPtr(c2)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Mul(OdGiColorRGB c, double s)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Mul__SWIG_8(OdGiColorRGB.getCPtr(c), s), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Mul(double s, OdGiColorRGB c)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Mul__SWIG_9(s, OdGiColorRGB.getCPtr(c)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Div(OdGiColorRGB c1, OdGiColorRGB c2)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Div__SWIG_0(OdGiColorRGB.getCPtr(c1), OdGiColorRGB.getCPtr(c2)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Div(OdGiColorRGB c, double s)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Div__SWIG_1(OdGiColorRGB.getCPtr(c), s), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiColorRGB Div(double s, OdGiColorRGB c)
		{
			OdGiColorRGB result = new OdGiColorRGB(GlobalsPINVOKE.Div__SWIG_2(s, OdGiColorRGB.getCPtr(c)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static IntPtr kNullSubentIndex
		{
			get
			{
				IntPtr result = GlobalsPINVOKE.kNullSubentIndex_get();
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
		}

		public static OdGeDoubleArray odgiGetAllDeviations(OdGiDeviation deviationObj, OdGePoint3d pointOnCurve)
		{
			OdGeDoubleArray result = new OdGeDoubleArray(GlobalsPINVOKE.odgiGetAllDeviations__SWIG_0(deviationObj.GetCPtr(), OdGePoint3d.getCPtr(pointOnCurve)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeDoubleArray odgiGetAllDeviations(OdGiDeviation deviationObj)
		{
			OdGeDoubleArray result = new OdGeDoubleArray(GlobalsPINVOKE.odgiGetAllDeviations__SWIG_1(deviationObj.GetCPtr()), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void odgsInitialize()
		{
			GlobalsPINVOKE.odgsInitialize();
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void odgsUninitialize()
		{
			GlobalsPINVOKE.odgsUninitialize();
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void odgiCalculateTextBasis(OdGeVector3d u, OdGeVector3d v, OdGeVector3d normal, OdGeVector3d direction, double height, double width, double oblique, bool bMirrorX, bool bMirrorY)
		{
			GlobalsPINVOKE.odgiCalculateTextBasis__SWIG_0(OdGeVector3d.getCPtr(u), OdGeVector3d.getCPtr(v), OdGeVector3d.getCPtr(normal), OdGeVector3d.getCPtr(direction), height, width, oblique, bMirrorX, bMirrorY);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void odgiCalculateTextBasis(OdGeVector3d u, OdGeVector3d v, OdGeVector3d normal, OdGeVector3d direction, double height, double width, double oblique, bool bMirrorX)
		{
			GlobalsPINVOKE.odgiCalculateTextBasis__SWIG_1(OdGeVector3d.getCPtr(u), OdGeVector3d.getCPtr(v), OdGeVector3d.getCPtr(normal), OdGeVector3d.getCPtr(direction), height, width, oblique, bMirrorX);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void odgiCalculateTextBasis(OdGeVector3d u, OdGeVector3d v, OdGeVector3d normal, OdGeVector3d direction, double height, double width, double oblique)
		{
			GlobalsPINVOKE.odgiCalculateTextBasis__SWIG_2(OdGeVector3d.getCPtr(u), OdGeVector3d.getCPtr(v), OdGeVector3d.getCPtr(normal), OdGeVector3d.getCPtr(direction), height, width, oblique);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static OdGiTextStyle odgiPrepareTextStyle(OdGiTextStyle pStyle, OdGiTextStyle res)
		{
			IntPtr intPtr = GlobalsPINVOKE.odgiPrepareTextStyle(OdGiTextStyle.getCPtr(pStyle), OdGiTextStyle.getCPtr(res));
			OdGiTextStyle result = (intPtr == IntPtr.Zero) ? null : new OdGiTextStyle(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool sameSortedArrays(OdDbStubPtrArray ar1, OdDbStubPtrArray ar2)
		{
			bool result = GlobalsPINVOKE.sameSortedArrays(OdDbStubPtrArray.getCPtr(ar1), OdDbStubPtrArray.getCPtr(ar2));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static uint getLineweight(OdGsEntityNode entNode)
		{
			uint lineweight = GlobalsPINVOKE.getLineweight(OdGsEntityNode.getCPtr(entNode));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return lineweight;
		}

		public static void setLineweight(OdGsEntityNode entNode, uint lwd)
		{
			GlobalsPINVOKE.setLineweight(OdGsEntityNode.getCPtr(entNode), lwd);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static int lineWeightIndex(LineWeight lw)
		{
			int result = GlobalsPINVOKE.lineWeightIndex((int)lw);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static LineWeight lineWeightByIndex(int lw)
		{
			LineWeight result = (LineWeight)GlobalsPINVOKE.lineWeightByIndex(lw);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGiTransientManager odgiGetTransientManager(OdRxObject pObject)
		{
			OdGiTransientManager result = (OdGiTransientManager)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.odgiGetTransientManager(OdRxObject.getCPtr(pObject)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void odgiSetTransientManager(OdGiTransientManager pManager, OdRxObject pObject)
		{
			GlobalsPINVOKE.odgiSetTransientManager(OdGiTransientManager.getCPtr(pManager), OdRxObject.getCPtr(pObject));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void odrxRegisterAuditInfoDestructorCallback(OdAuditInfoDelegate callbackFunc)
		{
			GlobalsPINVOKE.odrxRegisterAuditInfoDestructorCallback(callbackFunc);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void odrxUnregisterAuditInfoDestructorCallback()
		{
			GlobalsPINVOKE.odrxUnregisterAuditInfoDestructorCallback();
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static int getHexValue(int hexDigit)
		{
			int hexValue = GlobalsPINVOKE.getHexValue(hexDigit);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return hexValue;
		}

		public static void ExportDwfWrapper(DwExportParams param)
		{
			GlobalsPINVOKE.ExportDwfWrapper(DwExportParams.getCPtr(param));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static int lMaxDwfResolution
		{
			get
			{
				int result = GlobalsPINVOKE.lMaxDwfResolution_get();
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
		}

		public static int nDwf_v55
		{
			get
			{
				int result = GlobalsPINVOKE.nDwf_v55_get();
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
		}

		public static int nDwf_v42
		{
			get
			{
				int result = GlobalsPINVOKE.nDwf_v42_get();
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
		}

		public static int nDwf_v60
		{
			get
			{
				int result = GlobalsPINVOKE.nDwf_v60_get();
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
		}

		public static OdDgnImport createDgnImporter()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.createDgnImporter();
			OdDgnImport result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDgnImport)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDgnImport)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDgnImport)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdDwfImport createImporter()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.createImporter();
			OdDwfImport result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDwfImport)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDwfImport)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDwfImport)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool odutWcMatch(string arg0, string wcPattern)
		{
			bool result = GlobalsPINVOKE.odutWcMatch(arg0, wcPattern);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool odutWcMatchNoCase(string arg0, string wcPattern)
		{
			bool result = GlobalsPINVOKE.odutWcMatchNoCase(arg0, wcPattern);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static double oddbGetUnitsConversion(SWIGTYPE_p_OdDb__UnitsValue from, SWIGTYPE_p_OdDb__UnitsValue to)
		{
			double result = GlobalsPINVOKE.oddbGetUnitsConversion(SWIGTYPE_p_OdDb__UnitsValue.getCPtr(from), SWIGTYPE_p_OdDb__UnitsValue.getCPtr(to));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void OdClearFontTable()
		{
			GlobalsPINVOKE.OdClearFontTable();
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public const int SEEK_SET = 0;

		public const int SEEK_CUR = 1;

		public const int SEEK_END = 2;

		public const double OdaPI = Math.PI;

		public const double OdaPI2 = Math.PI*.5;

		public const double OdaPI4 = 0.78539816339744828;

		public const double Oda2PI = Math.PI*2;

		public const string ODRX_STATIC_MODULE_PATH = "\0";

		public const double INVALIDEXTENTS = 1E+20;

		public const int kOdGiIncludeScores = 2;

		public const int kOdGiRawText = 4;

		public const int kOdGiIncludePenups = 8;

		public const int kOdGiDrawShape = 16;

		public const int kOdGiIgnoreMIF = 32;

		public const int SCALAR_MIN = -2147483648;

		public const int SCALAR_MAX = 2147483647;

		public const int NULL = 0;
	}
}
